package com.lvmama.pangolin.task;

import com.lvmama.pangolin.busi.config.ConfigManager;
import com.lvmama.pangolin.entity.CommodityConditionVO;
import com.lvmama.pangolin.entity.ProductConditionVO;
import com.lvmama.pangolin.entity.RelevanceProduct;
import com.lvmama.pangolin.entity.link.TicketCommodityLink;
import com.lvmama.pangolin.entity.lmm.LMMTicketCommodity;
import com.lvmama.pangolin.entity.lmm.LMMTicketProduct;
import com.lvmama.pangolin.entity.mt.MTTicketCommodityItem;
import com.lvmama.pangolin.entity.qnr.QNRTicketCommodityItem;
import com.lvmama.pangolin.entity.tc.TCommodityItem;
import com.lvmama.pangolin.entity.tn.TNTicketCommodityItem;
import com.lvmama.pangolin.entity.xc.XCTicketCommodityItem;
import com.lvmama.pangolin.lmm.service.LMMTicketCommodityService;
import com.lvmama.pangolin.lmm.service.LMMTicketProductService;
import com.lvmama.pangolin.mt.service.MTTicketCommodityItemsService;
import com.lvmama.pangolin.qnr.service.QNRTicketCommodityItemsService;
import com.lvmama.pangolin.service.RelevanceCommodityService;
import com.lvmama.pangolin.service.RelevanceProductService;
import com.lvmama.pangolin.service.TicketCommodityScoreService;
import com.lvmama.pangolin.tc.service.TCCommodityItemsService;
import com.lvmama.pangolin.timer.CommonJob;
import com.lvmama.pangolin.tn.service.TNTicketCommodityItemsService;
import com.lvmama.pangolin.util.CommodityMatchUtil;
import com.lvmama.pangolin.util.CommodityRelationshipUtil;
import com.lvmama.pangolin.util.SpringContextUtil;
import com.lvmama.pangolin.xc.service.XCTicketCommodityItemsService;
import org.apache.log4j.Logger;
import org.quartz.JobExecutionContext;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.*;

/**
 * @Author:wangpeng
 * 自动匹配做过与驴妈妈产品关联的其他公司的商品：途牛、携程、美团、同城、去哪儿
 * <h1>必要条件1：产品必须与驴妈妈产品进行过关联</h1>
 * <h1>必要条件2：驴妈妈对应的产品和商品都存在</h1>
 * <h1>存在问题1：自动关联可以自动关联名称相近、价格相近、票据类型相同的门票；但不能关联如：[门票]直通车（商务或轿车车型）+门票—成人票 && 【携程特权日官方直营】玉龙雪山冰川公园索道票+雪山直通车往返车票（成人）  </h1>
 * <h1>存在问题2：定时器注入Service对象失败需要手动调用Spring上下文来获取</h1>
 * <h1>存在问题3：虽然每个业务对象的商品表数据结构相同，但是使用了不同表和mybatis进行匹配，难以对业务对象泛型化，使得重复代码较多</h1>
 * <h1>存在问题4：数据库表对金额存储为字符串类型，同时当前版本不能使用cast等函数进行转换，故而不能使用价格进行筛选</h1>
 * <h1>存在问题5：采用按照业务进行分类实现，然后注入的方式可以减少本类的复杂度，但会出现MyBatis无法注入</h1>
 */
public class AutoMachCommodity extends CommonJob {
    
    private static final Logger logger = Logger.getLogger(AutoMachCommodity.class);
    /**
     * 配置于数据库的全局系统配置对象
     */
    ConfigManager config = ConfigManager.getInstance();

    /**
     * 获取系统配置价格允许偏差度
     */
    String _COMMODITY_PRICE_DEVIATION=config.getParamValue("COMMODITY_PRICE_DEVIATION","COMMODITY_PRICE_DEVIATION");
    /**
     * 商品匹配评分最靠前的范围
     */
    String _COMMODITY_MATCH_MAX_TIMES=config.getParamValue("COMMODITY_MATCH_MAX_TIMES","COMMODITY_MATCH_MAX_TIMES");
    /**
     * 1-50价格区间的偏差度
     */
    String _HALF_HUNDRED=config.getParamValue("DEVIATION_HALF_HUNDRED","DEVIATION_HALF_HUNDRED");
    public final float DEVIATION_HALF_HUNDRED =(_HALF_HUNDRED!=null&&!"".equals(_HALF_HUNDRED))?Float.valueOf(_HALF_HUNDRED):0.7f;
    /**
     * 51-100价格区间的偏差度
     */
    String _TO_HUNDRED=config.getParamValue("DEVIATION_TO_HUNDRED","DEVIATION_TO_HUNDRED");
    public final float DEVIATION_TO_HUNDRED =(_TO_HUNDRED!=null&&!"".equals(_TO_HUNDRED))?Float.valueOf(_TO_HUNDRED):0.6F;
    /**
     * 101-200价格区间的偏差度
     */
    String _ONE_TWO_HUNDRED=config.getParamValue("DEVIATION_BETWEEN_ONE_TWO_HUNDRED","DEVIATION_BETWEEN_ONE_TWO_HUNDRED");
    public final float DEVIATION_BETWEEN_ONE_TWO_HUNDRED =(_ONE_TWO_HUNDRED!=null&&!"".equals(_ONE_TWO_HUNDRED))?Float.valueOf(_ONE_TWO_HUNDRED):0.45F;

    /**
     * 201-300价格区间的偏差度
     */
    String _TWO_THR_HUNDRED=config.getParamValue("DEVIATION_BETWEEN_TWO_THR_HUNDRED","DEVIATION_BETWEEN_TWO_THR_HUNDRED");
    public final float DEVIATION_BETWEEN_TWO_THR_HUNDRED =(_TWO_THR_HUNDRED!=null&&!"".equals(_TWO_THR_HUNDRED))?Float.valueOf(_TWO_THR_HUNDRED):0.4F;

    /**
     * 301-600价格区间的偏差度
     */
    String _THR_SIX_HUNDRED=config.getParamValue("DEVIATION_BETWEEN_THR_SIX_HUNDRED","DEVIATION_BETWEEN_THR_SIX_HUNDRED");
    public final float DEVIATION_BETWEEN_THR_SIX_HUNDRED =(_THR_SIX_HUNDRED!=null&&!"".equals(_THR_SIX_HUNDRED))?Float.valueOf(_THR_SIX_HUNDRED):0.35F;
    /**
     * 601以上的价格偏差度
     */
    String _OVER_SIX_HUNDRED=config.getParamValue("DEVIATION_OVER_SIX_HUNDRED","DEVIATION_OVER_SIX_HUNDRED");
    public final float DEVIATION_OVER_SIX_HUNDRED =(_OVER_SIX_HUNDRED!=null&&!"".equals(_OVER_SIX_HUNDRED))?Float.valueOf(_OVER_SIX_HUNDRED):0.3F;

    public final int COMMODITY_MATCH_MAX_TIMES=(_COMMODITY_MATCH_MAX_TIMES!=null&&!"".equals(_COMMODITY_MATCH_MAX_TIMES))?Integer.valueOf(_COMMODITY_MATCH_MAX_TIMES):5;

    public static final int NO_LINKED = 0;//未关联标志

    public static final int LINKED = 1;//已经关联标志

    public static final String BUSINESS_CODE="TICKET";//业务类型：门票类
    
    public static final String CODE_MT="mt";//美团业务
    
    public static final String CODE_TN="tn";//途牛业务
    
    public static final String CODE_QNR="qnr";//去哪儿业务
    
    public static final String CODE_XC="xc";//携程业务
    
    public static final String CODE_TC="tc";//同城业务

    public static final int MAX_LEN_COMMODITY_RELNAME = 98;//商品真实名称最大长度

    @Autowired
    public RelevanceProductService relevanceProductService;

    @Autowired
    public RelevanceCommodityService relevanceCommodityService;

    @Autowired
    public LMMTicketProductService lmmProductService;

    @Autowired
    public LMMTicketCommodityService lmmCommodityService;

    @Autowired
    public MTTicketCommodityItemsService mtCommodityService;

    @Autowired
    public XCTicketCommodityItemsService xcCommodityService;

    @Autowired
    public QNRTicketCommodityItemsService qnrCommodityService;

    @Autowired
    public TCCommodityItemsService tcCommodityService;

    @Autowired
    public TNTicketCommodityItemsService tnCommodityService;

    @Autowired
    public TicketCommodityScoreService scoreService;

    @Autowired
    public CommodityRelationshipUtil relationshipUtil;

    @Autowired
    private CommodityMatchUtil commodityMatchUtil;

    /**
     * <h1>本方法用于处理自动匹配商品</h1>
     * <p>基本思路：</p>
     * <p>1:扫描产品关联表，获取到所有关联的产品的id</p>
     * <p>2:根据获取到的驴妈妈产品id，查询驴妈妈的产品</p>
     * <p>3:根据驴妈妈的产品，查询该产品下的所有商品，并遍历对应产品下所有商品，寻找能与该商品匹配的其他公司商品</p>
     */
    public void AutoMatch()
    {
        logger.info("关联产品对驴妈妈商品的自动匹配开始 ****** ");
        int _mtRelationBeforeMatch = 0;//美团匹配前商品关联条数
        int _xcRelationBeforeMatch = 0;//携程匹配前商品关联条数
        int _tnRelationBeforeMatch = 0;//途牛匹配前商品关联条数
        int _qnrRelationBeforeMatch = 0;//去哪儿匹配前商品关联条数
        int _tcRelationBeforeMatch = 0;//同城匹配前商品关联条数
        try {
            _mtRelationBeforeMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_MT);
            _xcRelationBeforeMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_XC);
            _tnRelationBeforeMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_TN);
            _qnrRelationBeforeMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_QNR);
            _tcRelationBeforeMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_TC);

            ProductConditionVO pcvo = new ProductConditionVO();
            LMMTicketProduct lmmTicketProduct = null;
            pcvo.setBusinessCode(BUSINESS_CODE);
            /**
             * 根据业务类型：门票查询所有关联产品
             */
            List<RelevanceProduct> listRelevanceProduct = relevanceProductService.viewAllRelevanceWithPCVO(pcvo);

            if(listRelevanceProduct!=null && !listRelevanceProduct.isEmpty())
            {
                for(RelevanceProduct rp : listRelevanceProduct)//产品关联表可以获取到所有产品ID
                {
                    lmmTicketProduct = lmmProductService.selectByProductId(rp.getProdId());
                    if(lmmTicketProduct == null || "".equals(lmmTicketProduct.getProductId()))//驴妈妈产品为空
                    {
                        continue;
                    }
                    CommodityConditionVO commodityConditionVO = new CommodityConditionVO();
                    commodityConditionVO.setProductId(lmmTicketProduct.getProductId());//获取指定产品id下的商品，指定产品id作为筛选条件
                    List<LMMTicketCommodity> lmmAllCommoditiesThisProd = lmmCommodityService.selectByProdIdAll(commodityConditionVO);//得到该产品下所有的驴妈妈商品
                    if(lmmAllCommoditiesThisProd==null || lmmAllCommoditiesThisProd.isEmpty())//驴妈妈对应产品不存在商品列表
                    {
                        continue;
                    }
                    List<TicketCommodityLink> listRelCommodities_mt=null;//驴妈妈与美团关联的商品
                    List<TicketCommodityLink> listRelCommodities_xc=null;//驴妈妈与携程关联的商品
                    List<TicketCommodityLink> listRelCommodities_qnr=null;//驴妈妈与去哪儿关联的商品
                    List<TicketCommodityLink> listRelCommodities_tc=null;//驴妈妈与同城关联的商品
                    List<TicketCommodityLink> listRelCommodities_tn=null;//驴妈妈与途牛关联的商品
                    for(LMMTicketCommodity commodity: lmmAllCommoditiesThisProd)
                    {
                        /**
                         * 去除组合票
                         */
                        if(commodityMatchUtil.isCombinedCommodity(commodity.getCommodityName()))
                        {
                            continue;
                        }
                        if(commodity.getCommodityName()==null || "".equals(commodity.getCommodityName()))
                        {
                            commodity.setCommodityName(commodity.getSceneryName());//使用景点名称代替商品名称
                        }
                        /**
                         * 处理美团具有产品关联时的业务
                         */
                        if(rp.getProdIdMT()!=null && !"".equals(rp.getProdIdMT()))
                        {
                            listRelCommodities_mt = relevanceCommodityService.selectByCommProdComp(lmmTicketProduct.getProductId(),commodity.getCommodityId(),CODE_MT);
                            /**
                             * 处理美团对该商品没有关联的业务
                             */
                            if (listRelCommodities_mt==null||listRelCommodities_mt.isEmpty())//不存在该关联关系时，需要进行商品匹配关联
                            {
                                matchCommodity(commodity,CODE_MT,rp.getProdIdMT());
                            }
                        }
                        
                        /**
                         * 处理携程具有产品关联时的业务
                         */
                        if(rp.getProdIdXC()!=null && !"".equals(rp.getProdIdXC()))
                        {
                            listRelCommodities_xc = relevanceCommodityService.selectByCommProdComp(lmmTicketProduct.getProductId(),commodity.getCommodityId(),CODE_XC);
                            /**
                             * 处理美团对该商品没有关联的业务
                             */
                            if(listRelCommodities_xc==null||listRelCommodities_xc.isEmpty())
                            {
                                matchCommodity(commodity,CODE_XC,rp.getProdIdXC());
                            }
                        }
                        /**
                         * 处理去哪儿具有产品关联时的业务
                         */
                        if(rp.getProdIdQNR()!=null && !"".equals(rp.getProdIdQNR()))//去哪儿
                        {
                            listRelCommodities_qnr = relevanceCommodityService.selectByCommProdComp(lmmTicketProduct.getProductId(),commodity.getCommodityId(),CODE_QNR);
                            /**
                             * 处理去哪儿对该商品没有关联的业务
                             */
                            if(listRelCommodities_qnr==null||listRelCommodities_qnr.isEmpty())
                            {
                                matchCommodity(commodity,CODE_QNR,rp.getProdIdQNR());
                            }

                        }
                        /**
                         * 处理同城具有产品关联时的业务
                         */
                        if(rp.getProdIdTC()!=null && !"".equals(rp.getProdIdTC()))//同城
                        {

                            listRelCommodities_tc = relevanceCommodityService.selectByCommProdComp(lmmTicketProduct.getProductId(),commodity.getCommodityId(),CODE_TC);
                            /**
                             * 处理同城对该商品没有关联的业务
                             */
                            if(listRelCommodities_tc==null||listRelCommodities_tc.isEmpty())
                            {
                                matchCommodity(commodity,CODE_TC,rp.getProdIdTC());
                            }
                        }
                        /**
                         * 处理途牛具有产品关联时的业务
                         */
                        if(rp.getProdIdTN()!=null && !"".equals(rp.getProdIdTN()))//途牛
                        {
                            listRelCommodities_tn = relevanceCommodityService.selectByCommProdComp(lmmTicketProduct.getProductId(),commodity.getCommodityId(),CODE_TN);
                            /**
                             * 处理途牛对该商品没有关联的业务
                             */
                            if(listRelCommodities_tn==null||listRelCommodities_tn.isEmpty())
                            {
                                matchCommodity(commodity,CODE_TN,rp.getProdIdTN());
                            }

                        }

                    }
                }
            }

        }catch (Exception e )
        {
            e.printStackTrace();
            logger.error("关联产品对商品的自动匹配异常"+e.getMessage());
        }finally {
            int _mtRelationAfterMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_MT);
            int _xcRelationAfterMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_XC);
            int _tnRelationAfterMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_TN);
            int _qnrRelationAfterMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_QNR);
            int _tcRelationAfterMatch=relevanceCommodityService.selectCountByCompanyCode(CODE_TC);
            logger.info("本次匹配美团数据"+(_mtRelationAfterMatch - _mtRelationBeforeMatch)+" 条！");
            logger.info("本次匹配携程数据"+(_xcRelationAfterMatch - _xcRelationBeforeMatch)+" 条！");
            logger.info("本次匹配途牛数据"+(_tnRelationAfterMatch - _tnRelationBeforeMatch)+" 条！");
            logger.info("本次匹配去哪儿数据"+(_qnrRelationAfterMatch - _qnrRelationBeforeMatch)+" 条！");
            logger.info("本次匹配同城数据"+(_tcRelationAfterMatch - _tcRelationBeforeMatch)+" 条！");
        }
        logger.info("关联产品对商品的自动匹配正常结束 ****** ");

    }

    /**
     * 对传入的驴妈妈商品，按照公司进行匹配实际处理的方法
     * @param lmm 驴妈妈商品
     * @param code 公司
     * @param prodid 产品id
     */
    public void matchCommodity(LMMTicketCommodity lmm,String code,String prodid)
    {
        if(lmm==null)
        {
            return;
        }

        switch (code)
        {
            case CODE_MT:handleMatchCommodity_MT(lmm,prodid,code);break;//美团的具体匹配处理
            case CODE_XC:handleMatchCommodity_XC(lmm,prodid,code);break;//携程的具体匹配处理
            case CODE_QNR:handleMatchCommodity_QNR(lmm,prodid,code);break;//去哪儿的具体匹配处理
            case CODE_TC:handleMatchCommodity_TC(lmm,prodid,code);break;//同城的具体匹配处理
            case CODE_TN:handleMatchCommodity_TN(lmm,prodid,code);break;//途牛的具体匹配处理
            default:break;
        }

    }

    /**
     * 根据基准价格查询并筛选符合条件的去哪儿商品
     * <h1>商品具有可比性则其价格应该在相同维度水平</h1>
     * @param basePrice 基准价格
     * @param prodid 产品id
     * @return
     */
    public List<QNRTicketCommodityItem> getQNRFilterCommodities(String basePrice,String prodid)
    {
        List<QNRTicketCommodityItem> list = null;//由于表中价格设置为varchar,同时cast等函数无法在当前版本中使用，每次只能查询全部业务商品后进行价格比对
        List<QNRTicketCommodityItem> retList = new ArrayList<QNRTicketCommodityItem>();
        HashMap<String,String> map = new HashMap<>();
        map.put("product_id",prodid);
        list=qnrCommodityService.selectByProdidAndIsLinked(map);
        if(list==null || list.isEmpty())
        {
            return null;
        }
        if(basePrice!=null && !"".equals(basePrice))//当驴妈妈的商品具有价格时，可以查询价格在某一个范围波动的商品
        {
            for(QNRTicketCommodityItem qnr : list)
            {
                /**
                 * 去掉组合商品
                 */
                if(commodityMatchUtil.isCombinedCommodity(qnr.getCommodity_name()))
                {
                    continue;
                }
                if(qnr.getIs_link()==LINKED)//排除已经关联过的
                {
                    continue;
                }
                if(Integer.valueOf(qnr.getIs_link())==NO_LINKED)
                {
                    qnr.setIs_link(NO_LINKED);//将数据库中为空的值设置为0
                }
                if(qnr.getSale_price()!=null)//价格不为空，并且是未关联的商品
                {
                    double _qnrPrice = Double.valueOf(qnr.getSale_price());
                    double _basePrice = Double.valueOf(basePrice);
                    if(_qnrPrice<= _basePrice*(1+getDeviation(_basePrice)) && _qnrPrice>=(1-getDeviation(_basePrice)))//价格在合理区间内
                    {
                        retList.add(qnr);
                    }
                }

            }
        }
        return retList;//返回价格在允许偏差度内未关联过的商品
    }


    /**
     * 根据基准价格查询并筛选符合条件的美团商品
     * <h1>商品具有可比性则其价格应该在相同维度水平</h1>
     * @param basePrice 基准价格
     * @param prodid 产品id
     * @return
     */
    public List<MTTicketCommodityItem> getMTFilterCommodities(String basePrice,String prodid)
    {
        List<MTTicketCommodityItem> list = null;//由于表中价格设置为varchar,同时cast等函数无法在当前版本中使用，每次只能查询全部业务商品后进行价格比对
        List<MTTicketCommodityItem> retList = new ArrayList<MTTicketCommodityItem>();
        HashMap<String,String> map = new HashMap<>();
        map.put("product_id",prodid);
        list=mtCommodityService.selectByProdidAndIsLinked(map);
        if(list==null || list.isEmpty())
        {
            return null;
        }
        if(basePrice!=null && !"".equals(basePrice))//当驴妈妈的商品具有价格时，可以查询价格在某一个范围波动的商品
        {
            for(MTTicketCommodityItem mt : list)
            {
                /**
                 * 去掉组合商品
                 */
                if(commodityMatchUtil.isCombinedCommodity(mt.getCommodity_name()))
                {
                    continue;
                }
                if(mt.getIs_link()==LINKED)//排除已经关联过的
                {
                    continue;
                }
                if(Integer.valueOf(mt.getIs_link())==NO_LINKED)
                {
                    mt.setIs_link(NO_LINKED);//将数据库中为空的值设置为0
                }
                if(mt.getSale_price()!=null)//价格不为空，并且是未关联的商品
                {
                    double _mtPrice = Double.valueOf(mt.getSale_price());
                    double _basePrice = Double.valueOf(basePrice);
                    if(_mtPrice<= _basePrice*(1+getDeviation(_basePrice)) && _mtPrice>=(1-getDeviation(_basePrice)))//价格在合理区间内
                    {
                        retList.add(mt);
                    }
                }

            }
        }
        return retList;//返回价格在允许偏差度内未关联过的商品
    }



    /**
     * 根据基准价格查询并筛选符合条件的途牛商品
     * <h1>商品具有可比性则其价格应该在相同维度水平</h1>
     * @param basePrice 基准价格
     * @param prodid 产品id
     * @return
     */
    public List<TNTicketCommodityItem> getTNFilterCommodities(String basePrice,String prodid)
    {
        List<TNTicketCommodityItem> list = null;//由于表中价格设置为varchar,同时cast等函数无法在当前版本中使用，每次只能查询全部业务商品后进行价格比对
        List<TNTicketCommodityItem> retList = new ArrayList<TNTicketCommodityItem>();
        HashMap<String,String> map = new HashMap<>();
        map.put("product_id",prodid);
        list=tnCommodityService.selectByProdidAndIsLinked(map);
        if(list==null || list.isEmpty())
        {
            return null;
        }
        if(basePrice!=null && !"".equals(basePrice))//当驴妈妈的商品具有价格时，可以查询价格在某一个范围波动的商品
        {
            for(TNTicketCommodityItem tn : list)
            {
                /**
                 * 去掉组合商品
                 */
                if(commodityMatchUtil.isCombinedCommodity(tn.getCommodity_name()))
                {
                    continue;
                }
                if(tn.getIs_link()==LINKED)//排除已经关联过的
                {
                    continue;
                }
                if(Integer.valueOf(tn.getIs_link())==NO_LINKED)
                {
                    tn.setIs_link(NO_LINKED);//将数据库中为空的值设置为0
                }
                if(tn.getSale_price()!=null&&(tn.getIs_link()==NO_LINKED))//价格不为空，并且是未关联的商品
                {
                    double _tnPrice = Double.valueOf(tn.getSale_price());
                    double _basePrice = Double.valueOf(basePrice);
                    if(_tnPrice<= _basePrice*(1+getDeviation(_basePrice)) && _tnPrice>=(1-getDeviation(_basePrice)))//价格在合理区间内
                    {
                        retList.add(tn);
                    }
                }

            }
        }
        return retList;//返回价格在允许偏差度内未关联过的商品
    }

    /**
     * 根据基准价格查询并筛选符合条件的同城商品
     * <h1>商品具有可比性则其价格应该在相同维度水平</h1>
     * @param basePrice 基准价格
     * @param prodid 产品id
     * @return
     */
    public List<TCommodityItem> getTCFilterCommodities(String basePrice,String prodid)
    {
        List<TCommodityItem> list = null;//由于表中价格设置为varchar,同时cast等函数无法在当前版本中使用，每次只能查询全部业务商品后进行价格比对
        List<TCommodityItem> retList = new ArrayList<TCommodityItem>();
        HashMap<String,String> map = new HashMap<>();
        map.put("product_id",prodid);
        list=tcCommodityService.selectByProdidAndIsLinked(map);
        if(list==null || list.isEmpty())
        {
            return null;
        }
        if(basePrice!=null && !"".equals(basePrice))//当驴妈妈的商品具有价格时，可以查询价格在某一个范围波动的商品
        {
            for(TCommodityItem tc : list)
            {
                /**
                 * 去掉组合商品
                 */
                if(commodityMatchUtil.isCombinedCommodity(tc.getCommodity_name()))
                {
                    continue;
                }
                if(tc.getIs_link()==LINKED)//排除已经关联过的
                {
                    continue;
                }
                if(Integer.valueOf(tc.getIs_link())==NO_LINKED)
                {
                    tc.setIs_link(NO_LINKED);//将数据库中为空的值设置为0
                }
                if(tc.getSale_price()!=null&&(tc.getIs_link()==NO_LINKED))//价格不为空，并且是未关联的商品
                {
                    double _tcPrice = Double.valueOf(tc.getSale_price());
                    double _basePrice = Double.valueOf(basePrice);
                    if(_tcPrice<= _basePrice*(1+getDeviation(_basePrice)) && _tcPrice>=(1-getDeviation(_basePrice)))//价格在合理区间内
                    {
                        retList.add(tc);
                    }
                }

            }
        }
        return retList;//返回价格在允许偏差度内未关联过的商品
    }

    /**
     * 根据基准价格查询并筛选符合条件的携程商品
     * <h1>商品具有可比性则其价格应该在相同维度水平</h1>
     * @param basePrice 基准价格
     * @param prodid 产品id
     * @return
     */
    public List<XCTicketCommodityItem> getXCFilterCommodities(String basePrice,String prodid)
    {
        List<XCTicketCommodityItem> list = null;//由于表中价格设置为varchar,同时cast等函数无法在当前版本中使用，每次只能查询全部业务商品后进行价格比对
        List<XCTicketCommodityItem> retList = new ArrayList<XCTicketCommodityItem>();
        HashMap<String,String> map = new HashMap<>();
        map.put("product_id",prodid);//使用is_link=0不能查询出为null
        list=xcCommodityService.selectByProdidAndIsLinked(map);
        if(list==null || list.isEmpty())
        {
            return null;
        }
        if(basePrice!=null && !"".equals(basePrice))//当驴妈妈的商品具有价格时，可以查询价格在某一个范围波动的商品
        {
            for(XCTicketCommodityItem xc : list)
            {
                /**
                 * 去掉组合商品
                 */
                if(commodityMatchUtil.isCombinedCommodity(xc.getCommodity_name()))
                {
                    continue;
                }
                if(xc.getIs_link()==LINKED)//排除已经关联过的
                {
                    continue;
                }
                if(Integer.valueOf(xc.getIs_link())==NO_LINKED)
                {
                    xc.setIs_link(NO_LINKED);//将数据库中为空的值设置为0
                }
                if(xc.getSale_price()!=null)//价格不为空，并且是未关联的商品
                {
                    double _xcPrice = Double.valueOf(xc.getSale_price());
                    double _basePrice = Double.valueOf(basePrice);
                    if(_xcPrice<= _basePrice*(1+getDeviation(_basePrice)) && _xcPrice>=(1-getDeviation(_basePrice)))//价格在合理区间内
                    {
                        retList.add(xc);
                    }
                }

            }
        }
        return retList;//返回价格在允许偏差度内未关联过的商品
    }

    /**
     * <h1>返回驴妈妈商品的最佳美团匹配商品</h1>
     * @param lmm
     * @param list
     * @return
     */
    public MTTicketCommodityItem getBestMatchedCommodityFromMT(LMMTicketCommodity lmm,List<MTTicketCommodityItem> list)
    {
        MTTicketCommodityItem bestMatch = null;
        int i=0;
        if(list==null || list.isEmpty()||lmm==null)
        {
            return null;
        }
        if(lmm!=null && list!=null&& list.size()>0)
        {
            matchAndSortMTCommodity(lmm,list);//调用评分及排序流程
        }

        for(MTTicketCommodityItem mt:list)
        {
            if(i>COMMODITY_MATCH_MAX_TIMES)
            {
                break;
            }
            if(mt==null)
            {
                continue;
            }
            if(mt.getSale_price()!=null)
            {
                if(isAllowedPriceRange(lmm.getSalePrice(),mt.getSale_price(),getDeviation(Double.valueOf(lmm.getSalePrice()))))//价格是否在允许范围内
                {
                    bestMatch = mt;
                    break;
                }
            }
            i++;
        }

        return bestMatch;
    }


    /**
     * <h1>返回驴妈妈商品的最佳同城匹配商品</h1>
     * @param lmm
     * @param list
     * @return
     */
    public TCommodityItem getBestMatchedCommodityFromTC(LMMTicketCommodity lmm,List<TCommodityItem> list)
    {
        TCommodityItem bestMatch = null;
        int i=0;
        if(list==null || list.isEmpty()||lmm==null)
        {
            return null;
        }
        if(lmm!=null && list!=null&& list.size()>0)
        {
            matchAndSortTCCommodity(lmm,list);//调用评分及排序流程
        }

        for(TCommodityItem tc:list)
        {
            if(i>COMMODITY_MATCH_MAX_TIMES)
            {
                break;
            }
            if(tc==null)
            {
                continue;
            }
            if(tc.getSale_price()!=null)
            {
                if(isAllowedPriceRange(lmm.getSalePrice(),tc.getSale_price(),getDeviation(Double.valueOf(lmm.getSalePrice()))))//价格是否在允许范围内
                {
                    bestMatch = tc;
                    break;
                }
            }
            i++;
        }

        return bestMatch;
    }



    /**
     * <h1>返回驴妈妈商品的最佳途牛匹配商品</h1>
     * @param lmm
     * @param list
     * @return
     */
    public TNTicketCommodityItem getBestMatchedCommodityFromTN(LMMTicketCommodity lmm,List<TNTicketCommodityItem> list)
    {
        TNTicketCommodityItem bestMatch = null;
        int i=0;
        if(list==null || list.isEmpty()||lmm==null)
        {
            return null;
        }
        if(lmm!=null && list!=null&& list.size()>0)
        {
            matchAndSortTNCommodity(lmm,list);//调用评分及排序流程
        }

        for(TNTicketCommodityItem tn:list)
        {
            if(i>COMMODITY_MATCH_MAX_TIMES)
            {
                break;
            }
            if(tn==null)
            {
                continue;
            }
            if(tn.getSale_price()!=null)
            {
                if(isAllowedPriceRange(lmm.getSalePrice(),tn.getSale_price(),getDeviation(Double.valueOf(lmm.getSalePrice()))))//价格是否在允许范围内
                {
                    bestMatch = tn;
                    break;
                }
            }
            i++;
        }

        return bestMatch;
    }

    /**
     * <h1>返回驴妈妈商品的最佳去哪儿匹配商品</h1>
     * @param lmm
     * @param list
     * @return
     */
    public QNRTicketCommodityItem getBestMatchedCommodityFromQNR(LMMTicketCommodity lmm,List<QNRTicketCommodityItem> list)
    {
        QNRTicketCommodityItem bestMatch = null;
        int i =0;
        if(list==null || list.isEmpty()||lmm==null)
        {
            return null;
        }
        if(lmm!=null && list!=null&& list.size()>0)
        {
            matchAndSortQNRCommodity(lmm,list);//调用评分及排序流程
        }

        for(QNRTicketCommodityItem mt:list)
        {
            if(i>COMMODITY_MATCH_MAX_TIMES)
            {
                break;
            }
            if(mt==null)
            {
                continue;
            }
            if(mt.getSale_price()!=null)
            {
                if(isAllowedPriceRange(lmm.getSalePrice(),mt.getSale_price(),getDeviation(Double.valueOf(lmm.getSalePrice()))))//价格是否在允许范围内
                {
                    bestMatch = mt;
                    break;
                }
            }
            i++;
        }

        return bestMatch;
    }
    

    /**
     * <h1>返回驴妈妈商品的最佳携程匹配商品</h1>
     * @param lmm
     * @param list
     * @return
     */
    public XCTicketCommodityItem getBestMatchedCommodityFromXC(LMMTicketCommodity lmm,List<XCTicketCommodityItem> list)
    {
        XCTicketCommodityItem bestMatch = null;
        int i = 0;
        if(list==null || list.isEmpty()||lmm==null)
        {
            return null;
        }
        if(lmm!=null && list!=null&& list.size()>0)
        {
            matchAndSortXCCommodity(lmm,list);//调用评分及排序流程
        }

        for(XCTicketCommodityItem xc:list)
        {
            if(i>COMMODITY_MATCH_MAX_TIMES)
            {
                break;
            }

            if(xc==null)
            {
                continue;
            }
            if(xc.getSale_price()!=null)
            {
                if(isAllowedPriceRange(lmm.getSalePrice(),xc.getSale_price(),getDeviation(Double.valueOf(lmm.getSalePrice()))))//价格是否在允许范围内
                {
                    bestMatch = xc;
                    break;
                }
            }
            i++;
        }

        return bestMatch;
    }

    /**
     * 匹配驴妈妈和美团业务商品按照评分高低进行排序
     * @param commodity
     * @param list
     */
    public void matchAndSortMTCommodity(LMMTicketCommodity commodity,List<MTTicketCommodityItem> list)
    {
        relationshipUtil.matchAndSortMTTicketCommodity(commodity,list);
    }

    /**
     * 匹配驴妈妈和途牛业务商品按照评分高低进行排序
     * @param commodity
     * @param list
     */
    public void matchAndSortTNCommodity(LMMTicketCommodity commodity,List<TNTicketCommodityItem> list)
    {
        relationshipUtil.matchAndSortTNTicketCommodity(commodity,list);
    }

    /**
     * 匹配驴妈妈和同城业务商品按照评分高低进行排序
     * @param commodity
     * @param list
     */
    public void matchAndSortTCCommodity(LMMTicketCommodity commodity,List<TCommodityItem> list)
    {
        relationshipUtil.matchAndSortTCTicketCommodity(commodity,list);
    }

    /**
     * 匹配驴妈妈和携程业务商品按照评分高低进行排序
     * @param commodity
     * @param list
     */
    public void matchAndSortXCCommodity(LMMTicketCommodity commodity,List<XCTicketCommodityItem> list)
    {
        relationshipUtil.matchAndSortXCTicketCommodity(commodity,list);
    }

    /**
     * 匹配驴妈妈和去哪儿业务商品按照评分高低进行排序
     * @param commodity
     * @param list
     */
    public void matchAndSortQNRCommodity(LMMTicketCommodity commodity,List<QNRTicketCommodityItem> list)
    {
        relationshipUtil.matchAndSortQNRTicketCommodity(commodity,list);
    }

    /**
     * <h1>实际处理美团商品与驴妈妈商品关联的业务逻辑</h1>
     * <P>1：筛选美团商品</P>
     * <P>2：得到最佳匹配的商品</P>
     * <P>3：在商品关联表中增加该关联</P>
     * <P>4：将原来商品设置为已经关联</P>
     * @param lmm
     * @param prodId
     */
    public void handleMatchCommodity_MT(LMMTicketCommodity lmm,String prodId,String code)
    {
        if(lmm==null)
        {
            return;
        }
        //获得美团商品对驴妈妈的最佳匹配对象
        List<MTTicketCommodityItem> getFilteredList = getMTFilterCommodities(lmm.getSalePrice(),prodId);//获取筛选过的美团商品
        MTTicketCommodityItem bestMatch = null;
        if(getFilteredList!=null && getFilteredList.size()>0)
        {
            bestMatch=getBestMatchedCommodityFromMT(lmm,getFilteredList);//得到最佳匹配对象
        }
        if(bestMatch==null)
        {
            return;
        }

        //在商品关联表中要增加一条数据
        TicketCommodityLink insertLine = new TicketCommodityLink();
        insertLine.setRel_prod_id(prodId);//商品对应的真实产品id
        insertLine.setRel_commodity_id(bestMatch.getCommodity_id());//商品名称
        insertLine.setBusiness_code(BUSINESS_CODE);//设置业务编码
        insertLine.setCompany_code(code);//设置公司代码
        insertLine.setProd_id(lmm.getProductId());//驴妈妈产品id
        insertLine.setCommodity_id(lmm.getCommodityId());//驴妈妈商品id
        if(bestMatch.getCommodity_name().trim().length()>=MAX_LEN_COMMODITY_RELNAME)
        {
            bestMatch.setCommodity_name(bestMatch.getCommodity_name().trim().substring(0,MAX_LEN_COMMODITY_RELNAME));
        }
        insertLine.setRel_commodity_name(bestMatch.getCommodity_name().trim());//真实商品名称
        relevanceCommodityService.insertCommodityLink(insertLine);//插入数据库
        //原来美团商品要设置为已关联
        bestMatch.setIs_link(1);
        mtCommodityService.updateSelective(bestMatch);
    }


    /**
     * <h1>实际处理途牛商品与驴妈妈商品关联的业务逻辑</h1>
     * <P>1：筛选美团商品</P>
     * <P>2：得到最佳匹配的商品</P>
     * <P>3：在商品关联表中增加该关联</P>
     * <P>4：将原来商品设置为已经关联</P>
     * @param lmm
     * @param prodId
     */
    public void handleMatchCommodity_TN(LMMTicketCommodity lmm,String prodId,String code)
    {
        if(lmm==null)
        {
            return;
        }
        //获得美团商品对驴妈妈的最佳匹配对象
        List<TNTicketCommodityItem> getFilteredList = getTNFilterCommodities(lmm.getSalePrice(),prodId);//获取筛选过的美团商品
        TNTicketCommodityItem bestMatch = null;
        if(getFilteredList!=null && getFilteredList.size()>0)
        {
            bestMatch=getBestMatchedCommodityFromTN(lmm,getFilteredList);//得到最佳匹配对象
        }
        if(bestMatch==null)
        {
            return;
        }
        //在商品关联表中要增加一条数据
        TicketCommodityLink insertLine = new TicketCommodityLink();
        insertLine.setRel_prod_id(prodId);//商品对应的真实产品id
        insertLine.setRel_commodity_id(bestMatch.getCommodity_id());//商品名称
        insertLine.setBusiness_code(BUSINESS_CODE);//设置业务编码
        insertLine.setCompany_code(code);//设置公司代码
        insertLine.setProd_id(lmm.getProductId());//驴妈妈产品id
        insertLine.setCommodity_id(lmm.getCommodityId());//驴妈妈商品id
        if(bestMatch.getCommodity_name().trim().length()>=MAX_LEN_COMMODITY_RELNAME)
        {
            bestMatch.setCommodity_name(bestMatch.getCommodity_name().trim().substring(0,MAX_LEN_COMMODITY_RELNAME));
        }
        insertLine.setRel_commodity_name(bestMatch.getCommodity_name().trim());//真实商品名称
        relevanceCommodityService.insertCommodityLink(insertLine);//插入数据库
        //原来途牛商品要设置为已关联
        bestMatch.setIs_link(1);
        tnCommodityService.updateSelective(bestMatch);
    }


    /**
     * <h1>实际处理同城商品与驴妈妈商品关联的业务逻辑</h1>
     * <P>1：筛选美团商品</P>
     * <P>2：得到最佳匹配的商品</P>
     * <P>3：在商品关联表中增加该关联</P>
     * <P>4：将原来商品设置为已经关联</P>
     * @param lmm
     * @param prodId
     */
    public void handleMatchCommodity_TC(LMMTicketCommodity lmm,String prodId,String code)
    {
        if(lmm==null)
        {
            return;
        }
        //获得美团商品对驴妈妈的最佳匹配对象
        List<TCommodityItem> getFilteredList = getTCFilterCommodities(lmm.getSalePrice(),prodId);//获取筛选过的美团商品
        TCommodityItem bestMatch = null;
        if(getFilteredList!=null && getFilteredList.size()>0)
        {
            bestMatch=getBestMatchedCommodityFromTC(lmm,getFilteredList);//得到最佳匹配对象
        }
        if(bestMatch==null)
        {
            return;
        }
        //在商品关联表中要增加一条数据
        TicketCommodityLink insertLine = new TicketCommodityLink();
        insertLine.setRel_prod_id(prodId);//商品对应的真实产品id
        insertLine.setRel_commodity_id(bestMatch.getCommodity_id());//商品名称
        insertLine.setBusiness_code(BUSINESS_CODE);//设置业务编码
        insertLine.setCompany_code(code);//设置公司代码
        insertLine.setProd_id(lmm.getProductId());//驴妈妈产品id
        insertLine.setCommodity_id(lmm.getCommodityId());//驴妈妈商品id
        if(bestMatch.getCommodity_name().trim().length()>=MAX_LEN_COMMODITY_RELNAME)
        {
            bestMatch.setCommodity_name(bestMatch.getCommodity_name().trim().substring(0,MAX_LEN_COMMODITY_RELNAME));
        }
        insertLine.setRel_commodity_name(bestMatch.getCommodity_name().trim());//真实商品名称
        relevanceCommodityService.insertCommodityLink(insertLine);//插入数据库
        //原来同城商品要设置为已关联
        bestMatch.setIs_link(1);
        tcCommodityService.updateSelective(bestMatch);
    }



    /**
     * <h1>实际处理去哪儿商品与驴妈妈商品关联的业务逻辑</h1>
     * <P>1：筛选美团商品</P>
     * <P>2：得到最佳匹配的商品</P>
     * <P>3：在商品关联表中增加该关联</P>
     * <P>4：将原来商品设置为已经关联</P>
     * @param lmm
     * @param prodId
     */
    public void handleMatchCommodity_QNR(LMMTicketCommodity lmm,String prodId,String code)
    {
        if(lmm==null)
        {
            return;
        }
        //获得美团商品对驴妈妈的最佳匹配对象
        List<QNRTicketCommodityItem> getFilteredList = getQNRFilterCommodities(lmm.getSalePrice(),prodId);//获取筛选过的美团商品
        QNRTicketCommodityItem bestMatch = null;
        if(getFilteredList!=null && getFilteredList.size()>0)
        {
            bestMatch=getBestMatchedCommodityFromQNR(lmm,getFilteredList);//得到最佳匹配对象
        }
        if(bestMatch==null)
        {
            return;
        }
        //在商品关联表中要增加一条数据
        TicketCommodityLink insertLine = new TicketCommodityLink();
        insertLine.setRel_prod_id(prodId);//商品对应的真实产品id
        insertLine.setRel_commodity_id(bestMatch.getCommodity_id());//商品名称
        insertLine.setBusiness_code(BUSINESS_CODE);//设置业务编码
        insertLine.setCompany_code(code);//设置公司代码
        insertLine.setProd_id(lmm.getProductId());//驴妈妈产品id
        insertLine.setCommodity_id(lmm.getCommodityId());//驴妈妈商品id
        if(bestMatch.getCommodity_name().trim().length()>=MAX_LEN_COMMODITY_RELNAME)
        {
            bestMatch.setCommodity_name(bestMatch.getCommodity_name().trim().substring(0,MAX_LEN_COMMODITY_RELNAME));
        }
        insertLine.setRel_commodity_name(bestMatch.getCommodity_name().trim());//真实商品名称
        relevanceCommodityService.insertCommodityLink(insertLine);//插入数据库
        //原来去哪儿商品要设置为已关联
        bestMatch.setIs_link(1);
        qnrCommodityService.updateSelective(bestMatch);
    }

    /**
     * 判断价格是否在基准价格的偏差允许范围内
     * @param basePrice
     * @param comparePrice
     * @param deviation
     * @return
     */
    public boolean isAllowedPriceRange(String basePrice ,String comparePrice ,double deviation)
    {
        boolean ret = false;
        double _basePrice = Double.valueOf(basePrice);
        double _comparePrice = Double.valueOf(comparePrice);
        if(_comparePrice<=(1+deviation)*_basePrice&&_comparePrice>=(1-deviation)*_basePrice)
        {
            ret = true;
        }
        return ret;
    }

    /**
     * 初始化注入对象，由于定时器注入对象的优先级高，使用自动注入会失败
     */
    public void init()
    {
        if(relevanceProductService==null)
        {
            relevanceProductService = (RelevanceProductService) SpringContextUtil.getBean(RelevanceProductService.class);
        }

        if(relevanceCommodityService==null)
        {
            relevanceCommodityService = (RelevanceCommodityService) SpringContextUtil.getBean(RelevanceCommodityService.class);
        }

        if(lmmProductService==null)
        {
            lmmProductService = (LMMTicketProductService) SpringContextUtil.getBean(LMMTicketProductService.class);
        }
        if(lmmCommodityService==null)
        {
            lmmCommodityService = (LMMTicketCommodityService) SpringContextUtil.getBean(LMMTicketCommodityService.class);
        }

        if(mtCommodityService==null)
        {
            mtCommodityService = (MTTicketCommodityItemsService) SpringContextUtil.getBean(MTTicketCommodityItemsService.class);
        }
        if(scoreService==null)
        {
            scoreService = (TicketCommodityScoreService) SpringContextUtil.getBean(TicketCommodityScoreService.class);
        }
        if(relationshipUtil==null)
        {
            relationshipUtil = (CommodityRelationshipUtil) SpringContextUtil.getBean(CommodityRelationshipUtil.class);
        }
        if(commodityMatchUtil==null)
        {
            commodityMatchUtil = (CommodityMatchUtil) SpringContextUtil.getBean(CommodityMatchUtil.class);
        }
        if(xcCommodityService==null)
        {
            xcCommodityService = (XCTicketCommodityItemsService)SpringContextUtil.getBean(XCTicketCommodityItemsService.class);
        }

        if(qnrCommodityService==null)
        {
            qnrCommodityService = (QNRTicketCommodityItemsService)SpringContextUtil.getBean(QNRTicketCommodityItemsService.class);
        }


        if(tnCommodityService==null)
        {
            tnCommodityService = (TNTicketCommodityItemsService)SpringContextUtil.getBean(TNTicketCommodityItemsService.class);
        }

        if(tcCommodityService==null)
        {
            tcCommodityService = (TCCommodityItemsService)SpringContextUtil.getBean(TCCommodityItemsService.class);
        }

    }
    
    @Override
    public void runJob(JobExecutionContext context, String parameter) 
    {
        try{
            init();
            AutoMatch();
        }catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    /**
     * <h1>实际处理携程商品与驴妈妈商品关联的业务逻辑</h1>
     * <P>1：筛选携程商品</P>
     * <P>2：得到最佳匹配的商品</P>
     * <P>3：在商品关联表中增加该关联</P>
     * <P>4：将原来商品设置为已经关联</P>
     * @param lmm
     * @param prodId
     */
    public void handleMatchCommodity_XC(LMMTicketCommodity lmm,String prodId,String code)
    {
        if(lmm==null)
        {
            return;
        }
        //获得携程商品对驴妈妈的最佳匹配对象
        List<XCTicketCommodityItem> getFilteredList = getXCFilterCommodities(lmm.getSalePrice(),prodId);//获取筛选过的美团商品
        XCTicketCommodityItem bestMatch = null;
        if(getFilteredList!=null && getFilteredList.size()>0)
        {
            bestMatch=getBestMatchedCommodityFromXC(lmm,getFilteredList);//得到最佳匹配对象
        }
        if(bestMatch==null)
        {
            return;
        }
        //在商品关联表中要增加一条数据
        TicketCommodityLink insertLine = new TicketCommodityLink();
        insertLine.setRel_prod_id(prodId);//商品对应的真实产品id
        insertLine.setRel_commodity_id(bestMatch.getCommodity_id());//商品名称
        insertLine.setBusiness_code(BUSINESS_CODE);//设置业务编码
        insertLine.setCompany_code(code);//设置公司代码
        insertLine.setProd_id(lmm.getProductId());//驴妈妈产品id
        insertLine.setCommodity_id(lmm.getCommodityId());//驴妈妈商品id
        if(bestMatch.getCommodity_name().trim().length()>=MAX_LEN_COMMODITY_RELNAME)
        {
            bestMatch.setCommodity_name(bestMatch.getCommodity_name().trim().substring(0,MAX_LEN_COMMODITY_RELNAME));
        }
        insertLine.setRel_commodity_name(bestMatch.getCommodity_name().trim());//真实商品名称
        relevanceCommodityService.insertCommodityLink(insertLine);//插入数据库
        //原来携程商品要设置为已关联
        bestMatch.setIs_link(1);
        xcCommodityService.updateSelective(bestMatch);
    }


    /**
     * <h1>根据价格判断其允许的价格偏差度</h1>
     * <p>由于不同价格对于相同偏差度的反应不同：比如￥50元的商品可以允许70%的偏差（即：￥15-￥85在可接受的范围）</p>
     * <p>但￥1000元的商品，偏差度70%就不合适。</p>
     * <p>但￥1元-￥50的商品，偏差度建议 70%。</p>
     * <p>但￥51元-￥100的商品，偏差度建议 60%。</p>
     * <p>但￥101元-￥200的商品，偏差度建议 45%。</p>
     * <p>但￥201元-￥300的商品，偏差度建议 40%。</p>
     * <p>但￥301元-￥600的商品，偏差度建议 35%。</p>
     * <p>但￥601元-以上的商品，偏差度建议 30%。</p>
     * @param _price
     * @return
     */
    public float getDeviation(Double _price)
    {

        if(50>=_price&&_price>=0)
        {
            return DEVIATION_HALF_HUNDRED;

        }else if(100>=_price&&_price>50)
        {
            return DEVIATION_TO_HUNDRED;

        }else if(200>=_price&&_price>100)
        {
            return DEVIATION_BETWEEN_ONE_TWO_HUNDRED;

        }else if(300>=_price&&_price>200)
        {
            return DEVIATION_BETWEEN_TWO_THR_HUNDRED;

        }else if(600>=_price&&_price>300)
        {
            return DEVIATION_BETWEEN_THR_SIX_HUNDRED;

        }else if(_price>600)
        {
            return DEVIATION_OVER_SIX_HUNDRED;

        }else
        {
            return 0f;
        }
    }
}
